# -*- coding: utf-8 -*-
# @Time    : 2024/6/5 13:37
# @Author  : yujiahao
# @File    : 01_variable_calculation.py
# @description:Python中的变量

'''
    一、Python中的变量
        【变量】就是把程序运行的中间结果临时存在内存中,以便后续代码使用。
        【变量的作用】:昵称,就是代指内存中某个地址中的内容

        1、 定义一个变量
            Python：
                name = "meet"
                说明：name （是一个变量名） = （是一个赋值操作  赋值就是将值交给name） 'Meet' （是一个值）
            Java： String name = "meet";
            Scala： val name = "meet"   / var name = "meet" (不可变/可变)
        2、 变量的定义规则
            - 变量名由字母,数字,下划线组成
            - 变量名禁止使用数字开头
            - 禁止使用Python中的关键字以及内置函数的名字
                关键字如下:
                    ['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
            -不建议使用中文和拼音
            -变量名要具有意义
            -变量名区分大小写
            -推荐写法:
                >> 驼峰体: AgeOfOldboy = 56
                >> 下划线:age_of_oldboy = 56
        这是两种写法,Python中一般是试用下划线，Java和Scala中的变量一般为小驼峰
        3、Java、Scala 和 Python 的命名对比
            特性	                Java                	    Scala	                               Python
            类名	        大驼峰命名法（PascalCase）	    大驼峰命名法（PascalCase）	            大驼峰命名法（PascalCase）
            变量名	    小驼峰命名法（camelCase）	    小驼峰命名法（camelCase）	            小写字母，单词间用下划线分隔（snake_case）
            方法名	    小驼峰命名法（camelCase）	    小驼峰命名法（camelCase）	            小写字母，单词间用下划线分隔（snake_case）
            常量名	    全大写字母，单词间用下划线分隔	全大写字母，单词间用下划线分隔	        全大写字母，单词间用下划线分隔
            包名	        全小写字母，单词间用点分隔      全小写字母，单词间用点分隔	            全小写字母，单词间用点分隔（小写字母）
            参数名	    小驼峰命名法（camelCase）	    小驼峰命名法（camelCase）	            小写字母，单词间用下划线分隔（snake_case）
            泛型类型参数	单个大写字母，如 T, E, K, V 等	单个大写字母，如 T, E, K, V 等	        通常不使用泛型类型参数，但如果使用，也会使用大写字母（如 T）
        4、变量的赋值操作
            代码的运行是从上至下的执行,并且在内存中只能用一个名字相同的标签.

        5、常量
            常量就是将变量名大写,尽量保持不更改的一种量 这个常量有是干什么的呢 其实生活中就有一些定死了的量 比如生日,身份证等 咱们代码中，也应该有一些这样的东西，咱们从设计之初就是不让任何人改变的，所以这个东西就是常量。

    二、注释
        在你写代码时，有些代码写的比较经典，或者过于复杂，你一眼看不出来，怎么办，比如在文言文中，有些出处或者偏难怪的文字，你是不是不理解？ 那么怎么办呢？是不是就得有简单说明。
        1、单行注释：
            Java 和 Scala 使用 //。
            Python 使用 #。
        2、多行注释：
            Java 和 Scala 使用 /* ... */。
            Python 使用多个 # 或三重引号 """ ... """。
        3、文档字符串：
            Java 使用 /** ... */，并且 JavaDoc 工具可以解析这些注释。
            Scala 使用 /** ... */，并且 ScalaDoc 工具可以解析这些注释。
            Python 使用三重引号 """ ... """ 或 ''''''，并且 Pydoc 工具可以解析这些注释。
        一般的建议如下：我个人来讲，建议尽量多写一点注释，尤其初学者，远久代码注释写的少可能不清楚是怎么回事儿
            注释的目的：注释应当解释为什么做某事，而不是解释代码在做什么。代码的逻辑应当通过其自身的清晰性来展现。
            保持简洁：注释应当简洁明了，避免冗长。
            更新注释：当代码发生变化时，确保相应的注释也得到更新，以保持一致性。
            
            
            
            
    三、基础数据类型
    
        1、基础数据类型对比
            特性          Java	                        Scala	                 Python
            整数类型	   byte, short, int, long	    Byte, Short, Int, Long	        int
            浮点类型	   float, double	            Float, Double	                float
            字符类型	   char	                        Char	                        str (单字符)
            布尔类型	   boolean	                    Boolean	                        bool
            字符串类型   String	                    String	                        str
            其他类型	    null (空引用)	            Null, Unit	                    None (空值)
        
        2、基础类型的范围(要记下来)
        
            ① Java 基础数据类型及其范围
                数据类型	    大小	        范围
                byte	    1 字节	 -128 到 127
                short	    2 字节	 -32,768 到 32,767
                int	        4 字节	-2^31 到 2^31-1
                long	    8 字节	-2^63 到 2^63-1
                float	    4 字节	约 ±1.4E-45 到 ±3.4E38
                double	    8 字节	约 ±4.9E-324 到 ±1.7E308
                char	    2 字节	0 到 65,535 (单个 Unicode 字符)
                boolean	    1 位	true 或 false
            ② Scala 基础数据类型及其范围
            Scala 的基础数据类型与 Java 基本相同，因为 Scala 运行在 JVM 上，并且使用相同的基本数据类型。
            
                数据类型	     大小	    范围
                Byte	    1 字节	-128 到 127
                Short	    2 字节	-32,768 到 32,767
                Int	        4 字节	-2^31 到 2^31-1
                Long	    8 字节	-2^63 到 2^63-1
                Float	    4 字节	约 ±1.4E-45 到 ±3.4E38
                Double	    8 字节	约 ±4.9E-324 到 ±1.7E308
                Char	    2 字节	0 到 65,535 (单个 Unicode 字符)
                Boolean	    1 位	true 或 false
            ③ Python 基础数据类型及其范围
            Python 是动态类型语言，因此它的整数和浮点数没有固定的大小限制，取决于底层实现（通常是基于 C 的实现）。

                数据类型	大小	    范围
                int	    动态	    任意精度（受限于内存）
                float	动态	    约 ±1.8E-308 到 ±1.8E308
                str	    动态	    任意长度（受限于内存）
                bool	1 位	True 或 False
                None	-	    表示空值或无效值
                
            其他注意事项
                内存管理：Python 的整数和浮点数没有固定的大小限制，这使得它们在处理大数值时更加灵活，但也可能导致内存占用较大。Java 和 Scala 则有固定的大小限制，更加节省内存。
                类型转换：在 Java 和 Scala 中，类型转换通常需要显式进行，而在 Python 中，类型转换更加动态和灵活。
                性能：由于 Java 和 Scala 的数据类型有固定大小，因此在性能上通常比 Python 更优，特别是在处理大量数据时。
            通过理解这些基础数据类型的范围和特性，可以更好地在不同语言中编写和优化代码。不同语言有不同的类型系统和内存管理机制，但核心概念是相同的，即表示和操作基本数据。
    四、字符串
      
        在 Java、Scala 和 Python 中的字符串使用和特性。

            1. Java 中的字符串
            
               在 Java 中，字符串是由 `java.lang.String` 类表示的。字符串是不可变的对象，这意味着一旦创建了字符串对象，其内容就无法更改。
            
               创建字符串:
               String str1 = "Hello, World!";
               String str2 = new String("Hello, World!");
            
               常用操作:
               - 长度：str.length()
               - 字符访问：str.charAt(index)
               - 子字符串：str.substring(start, end)
               - 拼接：str1 + str2 或 str1.concat(str2)
               - 比较：str1.equals(str2) 或 str1.equalsIgnoreCase(str2)
               - 查找：str.indexOf("substring") 或 str.contains("substring")
            
               示例:
               String str = "Hello, World!";
               System.out.println(str.length()); // 输出: 13
               System.out.println(str.charAt(0)); // 输出: H
               System.out.println(str.substring(7, 12)); // 输出: World
               System.out.println(str.concat(" How are you?")); // 输出: Hello, World! How are you?
            
               对于性能要求较高的字符串拼接，可以使用 `StringBuilder`（线程安全） 或 `StringBuffer`（线程不安全）:
               StringBuilder sb = new StringBuilder();
               sb.append("Hello, ");
               sb.append("World!");
               System.out.println(sb.toString()); // 输出: Hello, World!

            2. Scala 中的字符串
            
               在 Scala 中，字符串是由 `java.lang.String` 类表示的，因此它们与 Java 字符串有相同的特性和方法。此外，Scala 还提供了丰富的字符串操作方法和更简洁的语法。
            
               Scala 中的变量可以用 `val` 和 `var` 定义:
               - `val` 定义不可变变量（类似于 Java 中的 `final`）。
               - `var` 定义可变变量。
            
               创建字符串:
               val str1 = "Hello, World!"
               val str2 = new String("Hello, World!")
            
               常用操作:
               - 长度：str.length
               - 字符访问：str.charAt(index)
               - 子字符串：str.substring(start, end)
               - 拼接：str1 + str2 或 str1.concat(str2)
               - 比较：str1 == str2 或 str1.equalsIgnoreCase(str2)
               - 查找：str.indexOf("substring") 或 str.contains("substring")
            
               示例:
               val str = "Hello, World!"
               println(str.length) // 输出: 13
               println(str.charAt(0)) // 输出: H
               println(str.substring(7, 12)) // 输出: World
               println(str + " How are you?") // 输出: Hello, World! How are you?
            
               对于性能要求较高的字符串拼接，可以使用 `StringBuilder`:
               val sb = new StringBuilder
               sb.append("Hello, ")
               sb.append("World!")
               println(sb.toString) // 输出: Hello, World!

            3. Python 中的字符串
            
               在 Python 中，字符串是由 `str` 类表示的。字符串也是不可变的对象。
            
               创建字符串:
               str1 = "Hello, World!"
               str2 = str("Hello, World!")
            
               常用操作:
               - 长度：len(str)
               - 字符访问：str[index]
               - 子字符串：str[start:end]
               - 拼接：str1 + str2
               - 比较：str1 == str2 或 str1.lower() == str2.lower()
               - 查找：str.find("substring") 或 substring in str
            
               示例:
               str = "Hello, World!"
               print(len(str)) # 输出: 13
               print(str[0]) # 输出: H
               print(str[7:12]) # 输出: World
               print(str + " How are you?") # 输出: Hello, World! How are you?
            
               对于性能要求较高的字符串拼接，可以使用 `str.join()` 或 `io.StringIO`:
               parts = ["Hello, ", "World!"]
               result = "".join(parts)
               print(result) # 输出: Hello, World!
            
               from io import StringIO
               sb = StringIO()
               sb.write("Hello, ")
               sb.write("World!")
               print(sb.getvalue()) # 输出: Hello, World!
                
                这个蛮有意思的，在Python中，str.join(iterable)方法用于将可迭代对象中的元素连接成一个字符串，并在每两个元素之间插入指定的字符串。
                需要注意的是，join方法的参数必须是一个可迭代对象（如列表、元组或字符串），而不是单个字符串。
               
            4. 详细说明
            
               1. 不可变性：
                  - 在 Java、Scala 和 Python 中，字符串都是不可变的。一旦创建了字符串对象，其内容就无法更改。任何修改字符串内容的操作都会返回一个新的字符串对象。
            
               2. 字符串拼接：
                  - Java 和 Scala 中的字符串拼接可以使用 `+` 操作符或 `concat` 方法。在性能要求较高的场景中，建议使用 `StringBuilder` 或 `StringBuffer` 来拼接字符串，以减少内存分配和复制操作。
                  - Python 中的字符串拼接可以使用 `+` 操作符。在需要频繁拼接字符串的场景中，建议使用 `str.join()` 方法或 `io.StringIO` 来提高性能。
            
               3. 字符串比较：
                  -Java 中，== 比较引用，equals 比较内容。
                  -Scala 中，== 调用 equals 方法比较内容，eq 比较引用。
                  -Python 中，== 比较内容，is 比较引用。
            
               4. 字符串查找：
                  - Java 和 Scala 提供了 `indexOf` 和 `contains` 方法来查找子字符串的位置或判断子字符串是否存在。
                  - Python 提供了 `find` 方法和 `in` 关键字来查找子字符串的位置或判断子字符串是否存在。
            
               5. 字符串格式化：
                  - Java 提供了 `String.format` 和 `MessageFormat` 来进行字符串格式化。
                  - Scala 提供了 `String.format` 和插值字符串（如 `s"Hello, $name"`）来进行字符串格式化。
                  - Python 提供了 `%` 操作符、`str.format` 方法和 f 字符串（如 `f"Hello, {name}"`）来进行字符串格式化。

    通过理解这些字符串的特性和操作，可以更好地在不同语言中处理字符串数据，提高代码的可读性和效率。
    
    五、基本运算
    
       Java、Scala 和 Python 中的基础运算和字符串运算对比

        1. 算术运算
        - 加法：`+`
        - 减法：`-`
        - 乘法：`*`
        - 除法：`/`
        - 取余：`%`
        - 幂（仅 Python）：`**`
        - 地板除（仅 Python）：`//`
            在Python中，地板除法（floor division）是一种特殊的除法运算，它会将结果向下取整到最接近的整数。
            地板除法的结果总是小于或等于实际除法的结果
                   >> 7 除以 3 等于 2.3333...，地板除法会将其向下取整为 2。
                   >> 对负数进行地板除法时，结果会向负无穷方向取整：-7 除以 3 等于 -2.3333...，地板除法会将其向下取整为 -3。


        Java:
            int a = 10;
            int b = 3;
            int sum = a + b; // 13
            int diff = a - b; // 7
            int prod = a * b; // 30
            int quotient = a / b; // 3
            int remainder = a % b; // 1

        Scala:
            val a = 10
            val b = 3
            val sum = a + b // 13
            val diff = a - b // 7
            val prod = a * b // 30
            val quotient = a / b // 3
            val remainder = a % b // 1

        Python:
            a = 10
            b = 3
            sum = a + b  # 13
            diff = a - b  # 7
            prod = a * b  # 30
            quotient = a / b  # 3.333...
            remainder = a % b  # 1
            power = a ** b  # 1000
            floor_div = a // b  # 3

         2. 赋值运算
        - 赋值：`=`
        - 加后赋值：`+=`
        - 减后赋值：`-=`
        - 乘后赋值：`*=`
        - 除后赋值：`/=`
        - 取余后赋值：`%=`
        - 幂后赋值（仅 Python）：`**=`
        - 地板除后赋值（仅 Python）：`//=`

        Java:
            int c = 5;
            c += 3; // c = 8
            c -= 2; // c = 6
            c *= 4; // c = 24
            c /= 6; // c = 4
            c %= 3; // c = 1
        
        Scala:
            var c = 5
            c += 3 // c = 8
            c -= 2 // c = 6
            c *= 4 // c = 24
            c /= 6 // c = 4
            c %= 3 // c = 1
        
        Python:
            c = 5
            c += 3  # c = 8
            c -= 2  # c = 6
            c *= 4  # c = 24
            c /= 6  # c = 4.0
            c %= 3  # c = 1.0
            c **= 2  # c = 1.0
            c //= 1  # c = 1.0

        3. 比较运算
        - 等于：`==`
        - 不等于：`!=`
        - 大于：`>`
        - 小于：`<`
        - 大于等于：`>=`
        - 小于等于：`<=`
        
        Java:
            boolean isEqual = (a == b); // false
            boolean isNotEqual = (a != b); // true
            boolean isGreater = (a > b); // true
            boolean isLess = (a < b); // false
            boolean isGreaterOrEqual = (a >= b); // true
            boolean isLessOrEqual = (a <= b); // false
        
        Scala:
            val isEqual = (a == b) // false
            val isNotEqual = (a != b) // true
            val isGreater = (a > b) // true
            val isLess = (a < b) // false
            val isGreaterOrEqual = (a >= b) // true
            val isLessOrEqual = (a <= b) // false
        
        Python:
            isEqual = (a == b)  # False
            isNotEqual = (a != b)  # True
            isGreater = (a > b)  # True
            isLess = (a < b)  # False
            isGreaterOrEqual = (a >= b)  # True
            isLessOrEqual = (a <= b)  # False
        
        4. 逻辑运算
        - 与：`&&`（Java 和 Scala），`and`（Python）
        - 或：`||`（Java 和 Scala），`or`（Python）
        - 非：`!`（Java 和 Scala），`not`（Python）
        这里有点区别了，注意
        Java:
            boolean x = true;
            boolean y = false;
            boolean andResult = x && y; // false
            boolean orResult = x || y; // true
            boolean notResult = !x; // false
        
        Scala:
            val x = true
            val y = false
            val andResult = x && y // false
            val orResult = x || y // true
            val notResult = !x // false
        
        Python:
            x = True
            y = False
            andResult = x and y  # False
            orResult = x or y  # True
            notResult = not x  # False
        
        5. 位运算
        - 与：`&`
        - 或：`|`
        - 异或：`^`
        - 非：`~`
        - 左移：`<<`
        - 右移：`>>`
        - 无符号右移（仅 Java 和 Scala）：`>>>`
        
        Java:
            int p = 5; // 0101 in binary
            int q = 3; // 0011 in binary
            int andBitwise = p & q; // 0001 (1 in decimal)
            int orBitwise = p | q; // 0111 (7 in decimal)
            int xorBitwise = p ^ q; // 0110 (6 in decimal)
            int notBitwise = ~p; // 1010 (in binary, -6 in decimal)
            int leftShift = p << 1; // 1010 (10 in decimal)
            int rightShift = p >> 1; // 0010 (2 in decimal)
            int unsignedRightShift = p >>> 1; // 0010 (2 in decimal)
        
        Scala:
            val p = 5 // 0101 in binary
            val q = 3 // 0011 in binary
            val andBitwise = p & q // 0001 (1 in decimal)
            val orBitwise = p | q // 0111 (7 in decimal)
            val xorBitwise = p ^ q // 0110 (6 in decimal)
            val notBitwise = ~p // 1010 (in binary, -6 in decimal)
            val leftShift = p << 1 // 1010 (10 in decimal)
            val rightShift = p >> 1 // 0010 (2 in decimal)
            val unsignedRightShift = p >>> 1 // 0010 (2 in decimal)
        
        Python:
            p = 5  # 0101 in binary
            q = 3  # 0011 in binary
            andBitwise = p & q  # 0001 (1 in decimal)
            orBitwise = p | q  # 0111 (7 in decimal)
            xorBitwise = p ^ q  # 0110 (6 in decimal)
            notBitwise = ~p  # 1010 (in binary, -6 in decimal)
            leftShift = p << 1  # 1010 (10 in decimal)
            rightShift = p >> 1  # 0010 (2 in decimal)
        
         6. 字符串运算
        - 拼接：`+`
        - 重复（仅 Python）：`*`
        - 长度：`.length()`（Java），`.length`（Scala），`len()`（Python）
        - 子串：`.substring()`（Java），`.slice()`（Scala），切片 `[]`（Python）
        - 查找：`.indexOf()`（Java），`.indexOf()`（Scala），`.find()`（Python）
        
        Java:
            String str1 = "Hello";
            String str2 = "World";
            String concat = str1 + " " + str2; // "Hello World"
            int length = str1.length(); // 5
            String substring = str1.substring(1, 4); // "ell"
            int index = str1.indexOf("e"); // 1
        
        Scala:
            val str1 = "Hello"
            val str2 = "World"
            val concat = str1 + " " + str2 // "Hello World"
            val length = str1.length // 5
            val substring = str1.slice(1, 4) // "ell"
            val index = str1.indexOf("e") // 1
        
        Python:
            str1 = "Hello"
            str2 = "World"
            concat = str1 + " " + str2  # "Hello World"
            length = len(str1)  # 5
            substring = str1[1:4]  # "ell"
            index = str1.find("e")  # 1
            repeat = str1 * 3  # "HelloHelloHello"
            
    六、字符串切片规则比较
       
        【都是左闭右开，索引都是从0开始的】
        1. Java: 使用 `substring(beginIndex, endIndex)`，包括 `beginIndex` 但不包括 `endIndex`
        2. Scala: 使用 `slice(beginIndex, endIndex)`，包括 `beginIndex` 但不包括 `endIndex`
        3. Python: 使用 `str[start:end]`，包括 `start` 但不包括 `end`

        Java 切片示例
        
            1. 从索引 1 到 4（不包括 4）
               String str = "HelloWorld";
               String slice1 = str.substring(1, 4); // "ell"
            
            2. 从索引 0 到结尾
               String slice2 = str.substring(0); // "HelloWorld"
            
            3. 从索引 3 到结尾
               String slice3 = str.substring(3); // "loWorld"

        Scala 切片示例
        
            1. 从索引 1 到 4（不包括 4）
               val str = "HelloWorld";
               val slice1 = str.slice(1, 4); // "ell"
            
            2. 从索引 0 到结尾
               val slice2 = str.slice(0, str.length); // "HelloWorld"
            
            3. 从索引 3 到结尾
               val slice3 = str.slice(3, str.length); // "loWorld"
        
        Python 切片示例
        
            1. 从索引 1 到 4（不包括 4）
               str = "HelloWorld"
               slice1 = str[1:4]  # "ell"
            
            2. 从索引 0 到结尾
               slice2 = str[0:]  # "HelloWorld"
            
            3. 从索引 3 到结尾
               slice3 = str[3:]  # "loWorld"
            
            4. 从开始到索引 4（不包括 4）
               slice4 = str[:4]  # "Hell"
            
            5. 从索引 1 到倒数第 1 个字符
               slice5 = str[1:-1]  # "elloWorl"
            
            6. 使用步长
               slice6 = str[1:8:2]  # "elWr"
               slice7 = str[::-1]  # "dlroWolleH" 反转字符串
            
            7. 仅使用步长
               slice8 = str[::2]  # "Hlool" 每隔一个字符取一个
            
            8. 从索引 1 到索引 7（不包括 7），步长为 3
               slice9 = str[1:7:3]  # "eoo"
            
            9. 使用负步长
               slice10 = str[7:1:-2]  # "olW" 反向每隔一个字符取一个
            
            10. 使用负索引
                slice11 = str[-5:-1]  # "Worl"

    说明
    
    - Java 中的 `substring(beginIndex, endIndex)` 方法返回一个新字符串，它是此字符串的一个子字符串。子字符串从指定的 `beginIndex` 处开始，直到索引 `endIndex - 1` 处的字符。
    - Scala 中的 `slice(beginIndex, endIndex)` 方法返回一个包含从指定的 `beginIndex` 到 `endIndex - 1` 的所有字符的新字符串。
    - Python 中的切片语法 `str[start:end]` 返回从 `start` 索引到 `end - 1` 索引的子字符串。切片还可以使用步长 `str[start:end:step]`，并且可以使用负索引从字符串末尾开始计数。
    
    七、切片省略
    
    Java：substring 方法不支持省略参数，必须明确提供 beginIndex 和（可选的）endIndex。
    Scala：slice 方法不支持省略参数，必须明确提供 beginIndex 和 endIndex。
        在 Scala 中，:: 是一个用于列表操作的右结合操作符，用于将元素添加到列表的头部。它与字符串切片没有直接关系，字符串切片需要使用 slice 方法。
    Python：切片语法非常灵活，可以省略 start、end 和 step 参数，省略时它们会取默认值。
    
    在 Python 中，字符串切片的语法是 str[start:end:step]。当省略某些参数时，它们会取默认值。以下是对 :: 这种省略用法的详细解释：
        start 默认值是 0，这意味着切片从字符串的开头开始。
        end 默认值是字符串的长度，这意味着切片会一直到字符串的结尾。
        step 默认值是 1，这意味着切片会一个一个字符地进行。
        1. str[start:end]：省略 step，步长默认为 1。
        2. str[start:]：省略 end，切片到字符串的末尾。
        3. str[:end]：省略 start，从字符串的开头开始切片。
        4. str[start:end:step]：指定 start、end 和 step。
        5. str[::]：省略 start、end 和 step，返回整个字符串的副本。
        6. str[::step]：省略 start 和 end，但指定步长 step。
        7. str[start::step]：省略 end，但指定 start 和 step。
        8. str[:end:step]：省略 start，但指定 end 和 step。
        
        以下是一些具体的示例：
        
        str = "HelloWorld"
        
        # 1. str[start:end] 示例
        slice1 = str[1:4]  # "ell"
        
        # 2. str[start:] 示例
        slice2 = str[3:]  # "loWorld"
        
        # 3. str[:end] 示例
        slice3 = str[:4]  # "Hell"
        
        # 4. str[start:end:step] 示例
        slice4 = str[1:8:2]  # "elWr"
        
        # 5. str[::] 示例
        slice5 = str[::]  # "HelloWorld" 返回整个字符串
        
        # 6. str[::step] 示例
        slice6 = str[::2]  # "Hlool" 每隔一个字符取一个
        
        # 7. str[start::step] 示例
        slice7 = str[1::2]  # "elWrd" 从索引 1 开始，每隔一个字符取一个
        
        # 8. str[:end:step] 示例
        slice8 = str[:8:2]  # "Hlool" 从开始到索引 8（不包括 8），每隔一个字符取一个
        
       说明
        
        1. str[start:end]：从索引 start 开始到索引 end 之前的子字符串。
        2. str[start:]：从索引 start 开始到字符串的末尾。
        3. str[:end]：从字符串的开头到索引 end 之前。
        4. str[start:end:step]：从索引 start 开始到索引 end 之前，每隔 step 个字符取一个。
        5. str[::]：返回整个字符串的副本。
        6. str[::step]：从字符串的开头到结尾，每隔 step 个字符取一个。
        7. str[start::step]：从索引 start 开始到字符串的末尾，每隔 step 个字符取一个。
        8. str[:end:step]：从字符串的开头到索引 end 之前，每隔 step 个字符取一个。
'''



# todo 1、变量

# 变量赋值操作 ，这是一条单行注释
age1 = 18
age2 = age1
age1 = 12
age3 = age2
# 先猜一下再跑
print(age1,age2,age3)


# todo 2、注释
'''我是一条多行注释'''

"""我也是一行多行注释"""


# todo 3、基础数据类型

# 整数类型
a_byte = 10  # Python 没有单独的 byte 类型
a_short = 100  # Python 没有单独的 short 类型
an_int = 1000
a_long = 10000  # Python 3 中 int 和 long 是统一的

# 浮点类型
a_float = 10.5
a_double = 20.5  # Python 没有单独的 double 类型，float 就是双精度

# 字符类型
a_char = 'A'  # Python 没有单独的 char 类型，使用 str 类型

# 布尔类型
a_boolean = True

# 字符串类型
a_string = "Hello, World!"

# 空值
a_null_string = None


# todo 4、字符串
'''
str是字符串;也就是我们从小就接触的中文,如果我们在程序中直接把中文写入,程序是不能分辨这是个什么鬼东西.所以我们要遵循一种规则让计算机能够识别,这个规则就是只要是用引号引起来就是字符串
在Python中,凡是用引号引起来的,全是字符 .
字符 可以用单引号，双引号，或者三引号引起来，没有什么区别，只是一些特殊的格式需要不用的引号 比如：
'''

# 这个就需要单双引号配合。
msg = "My name is Yujiahao , I'm 18 years old!"

# 想写多个内容还需要使用换行的时候,就需要三引号。
msg_2 =""" 今天我想背一首诗
        七律·冬云
        ️  ☀️
        雪压冬云白絮飞，
        万花纷谢一时稀。
        高天滚滚寒流急，
        大地微微暖气吹。
        独有英雄驱虎豹，
        更无豪杰怕熊罴。
        梅花欢喜漫天雪，
        冻死苍蝇未足奇。
     """
# 拼接 join的话会迭代拼接参数里面的数据

print("".join(msg_2))

print(msg + msg_2)

print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')


# todo 5、基本运算
# 1. 算术运算

a = 10
b = 3
sum = a + b  # 13
diff = a - b  # 7
prod = a * b  # 30
quotient = a / b  # 3.333...
remainder = a % b  # 1
power = a ** b  # 1000
floor_div = a // b  # 3

print(f"加法 (a + b): {sum}")  # 加法
print(f"减法 (a - b): {diff}")  # 减法
print(f"乘法 (a * b): {prod}")  # 乘法
print(f"除法 (a / b): {quotient}")  # 除法
print(f"取余 (a % b): {remainder}")  # 取余
print(f"幂 (a ** b): {power}")  # 幂
print(f"地板除 (a // b): {floor_div}")  # 地板除


print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')


# 2. 赋值运算

c = 5
c += 3  # c = 8
print(f"加后赋值 (c += 3): {c}")  # 加后赋值
c -= 2  # c = 6
print(f"减后赋值 (c -= 2): {c}")  # 减后赋值
c *= 4  # c = 24
print(f"乘后赋值 (c *= 4): {c}")  # 乘后赋值
c /= 6  # c = 4.0
print(f"除后赋值 (c /= 6): {c}")  # 除后赋值
c %= 3  # c = 1.0
print(f"取余后赋值 (c %= 3): {c}")  # 取余后赋值
c **= 2  # c = 1.0
print(f"幂后赋值 (c **= 2): {c}")  # 幂后赋值
c //= 1  # c = 1.0
print(f"地板除后赋值 (c //= 1): {c}")  # 地板除后赋值

print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')

# 3. 比较运算

isEqual = (a == b)  # False
isNotEqual = (a != b)  # True
isGreater = (a > b)  # True
isLess = (a < b)  # False
isGreaterOrEqual = (a >= b)  # True
isLessOrEqual = (a <= b)  # False

print(f"等于 (a == b): {isEqual}")  # 等于
print(f"不等于 (a != b): {isNotEqual}")  # 不等于
print(f"大于 (a > b): {isGreater}")  # 大于
print(f"小于 (a < b): {isLess}")  # 小于
print(f"大于等于 (a >= b): {isGreaterOrEqual}")  # 大于等于
print(f"小于等于 (a <= b): {isLessOrEqual}")  # 小于等于

print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')


# 4. 逻辑运算

x = True
y = False
andResult = x and y  # False
orResult = x or y  # True
notResult = not x  # False

print(f"与 (x and y): {andResult}")  # 与
print(f"或 (x or y): {orResult}")  # 或
print(f"非 (not x): {notResult}")  # 非

print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')

# 5. 位运算

p = 5  # 0101 in binary
q = 3  # 0011 in binary
andBitwise = p & q  # 0001 (1 in decimal)
orBitwise = p | q  # 0111 (7 in decimal)
xorBitwise = p ^ q  # 0110 (6 in decimal)
notBitwise = ~p  # 1010 (in binary, -6 in decimal)
leftShift = p << 1  # 1010 (10 in decimal)
rightShift = p >> 1  # 0010 (2 in decimal)

print(f"位与 (p & q): {andBitwise}")  # 位与
print(f"位或 (p | q): {orBitwise}")  # 位或
print(f"位异或 (p ^ q): {xorBitwise}")  # 位异或
print(f"位非 (~p): {notBitwise}")  # 位非
print(f"左移 (p << 1): {leftShift}")  # 左移
print(f"右移 (p >> 1): {rightShift}")  # 右移


# 6. 字符串运算

str1 = "Hello"
str2 = "World"
concat = str1 + " " + str2  # "Hello World"
length = len(str1)  # 5
substring = str1[1:4]  # "ell"
index = str1.find("e")  # 1
repeat = str1 * 3  # "HelloHelloHello"

print(f"字符串拼接 (str1 + ' ' + str2): {concat}")  # 字符串拼接
print(f"字符串长度 (len(str1)): {length}")  # 字符串长度
print(f"子串 (str1[1:4]): {substring}")  # 子串
print(f"查找字符 'e' 的索引 (str1.find('e')): {index}")  # 查找字符
print(f"字符串重复 (str1 * 3): {repeat}")  # 字符串重复

print('\n------------------------------------------------☆☆☆分隔线☆☆☆------------------------------------------------\n')

# todo 7、切片


str = "HelloWorld"

# 1. str[start:end] 示例
slice1 = str[1:4]  # 从索引 1 到索引 4（不包括 4），得到 "ell"
print(f"str[1:4]: {slice1}  # 从索引 1 到索引 4（不包括 4），得到 'ell'")

# 2. str[start:] 示例
slice2 = str[3:]  # 从索引 3 开始到结尾，得到 "loWorld"
print(f"str[3:]: {slice2}  # 从索引 3 开始到结尾，得到 'loWorld'")

# 3. str[:end] 示例
slice3 = str[:4]  # 从开头到索引 4（不包括 4），得到 "Hell"
print(f"str[:4]: {slice3}  # 从开头到索引 4（不包括 4），得到 'Hell'")

# 4. str[start:end:step] 示例
slice4 = str[1:8:2]  # 从索引 1 到索引 8（不包括 8），每隔一个字符取一个，得到 "elWr"
print(f"str[1:8:2]: {slice4}  # 从索引 1 到索引 8（不包括 8），每隔一个字符取一个，得到 'elWr'")

# 5. str[::] 示例
slice5 = str[::]  # 返回整个字符串，得到 "HelloWorld"
print(f"str[::]: {slice5}  # 返回整个字符串，得到 'HelloWorld'")

# 6. str[::step] 示例
slice6 = str[::2]  # 每隔一个字符取一个，得到 "Hlool"
print(f"str[::2]: {slice6}  # 每隔一个字符取一个，得到 'Hlool'")

# 7. str[start::step] 示例
slice7 = str[1::2]  # 从索引 1 开始，每隔一个字符取一个，得到 "elWrd"
print(f"str[1::2]: {slice7}  # 从索引 1 开始，每隔一个字符取一个，得到 'elWrd'")

# 8. str[:end:step] 示例
slice8 = str[:8:2]  # 从开头到索引 8（不包括 8），每隔一个字符取一个，得到 "Hlool"
print(f"str[:8:2]: {slice8}  # 从开头到索引 8（不包括 8），每隔一个字符取一个，得到 'Hlool'")
